1. Field of the Invention
The present invention relates to object-oriented programmable components, and more particularly, to a method and system for processing data objects based on a high level object-oriented component infrastructure directed to providing efficient development of software applications and systems.
2. Description of the Related Art
Modern techniques for developing software applications are based on an object-oriented programming paradigm. In this paradigm, functionality of a programmable system is implemented as an interaction between programmable objects. The programmable object, according to the object-oriented paradigm, includes data structures and a set of procedures that retrieve data from the data structures and change contents of the data structures in accordance with particular rules. These procedures are called “methods,” and a plurality of methods, associated with an object, is referred to as an object interface.
Generally, objects within a programmable system belong to a particular common type and the objects of the same type have the same interface (i.e., a set of methods). The types of objects are referred to as classes. Object-oriented applications are typically developed using object-oriented programming languages, such as, for example C++, JAVA and C#. The object-oriented programming languages include structures for developing object-oriented executable code and can support classes and interfaces at the code level.
Typically, modern programmable systems rely on a component infrastructure. The component infrastructure provides a number of functional components (i.e., modules). Use of modules makes a system more efficient. For example, only modules whose functionality is needed for a particular application can be loaded. Several applications can use the same modules and, thereby, save memory space. The system is more flexible from a development point of view, since modules can be simply added (or replaced) to an existing system without changing an already implemented system.
In conventional implementations, division of a program code into modules is not implemented directly by means of programming language, whereas some of the older programming languages, such as, for example, Turbo Pascal have means for creating separate programmable modules. In more commonly used modern languages, such as C++ and C#, modular organization is implemented by a component infrastructure. The main task accomplished by the component infrastructure is to provide a mechanism for developing applications not in a form of a monolithic executable file, but as a set of modules that are developed and supported separately.
An example of a general-purpose component infrastructure is Microsoft Common Object Model (COM). This infrastructure defines common rules of software coding that can be used for a wide spectrum of applications. However, while being a general-purpose infrastructure, COM provides a very limited set of services performed by objects, and the services available are very low-level. A basic COM object can only support methods for increasing or decreasing a reference counter and for determining which interfaces are supported by the object. The high-level functionality (i.e., managing messages, object properties and logical connections between objects) has to be implemented by an application developer.
Therefore, when developing applications based on general purpose object-oriented infrastructures, such as COM, the high-level service interfaces for objects have to be created for each particular application. A set of the service interfaces depends on architecture of a particular application and on the tasks it accomplishes. Typically applications directed to a particular class of tasks, for example, to anti-virus processing, require similar sets of services implemented by a component infrastructure. The object infrastructure of a higher level that can provide a means for implementing typical functional elements (i.e., patterns) is generally needed for improving efficiency of application development.
A typical problem that needs to be solved when developing applications is controlling resource allocation and, in particular, controlling life-time of created objects. A reliable object infrastructure has to have a mechanism for preventing resource leaks, including leaks within programmable objects. Typically these means are implemented by various garbage collection mechanisms (for example, in COM, reference counters are used). However, in programmable applications it is often necessary to limit maximum amount of resources allocated for processing an individual request. Conventional general-purpose object-oriented infrastructures do not provide any means for accomplishing this task.
Another typical task is an inter-object transfer of information about events invoked during data processing. One of the important requirements for the information transfer between objects is an isolation of sender-objects from receiver-objects, so that a set of the receiver objects can be changed without any changes in the code of the sender-objects. An isolation of the receiver objects from the sender objects must also be ensured, so that the receiver object can receive messages of a particular type without knowing which object was the sender of the message. Conventional general purpose object-oriented infrastructures, such as COM, do not have a built-in mechanism for support of inter-object message transfer satisfying the isolation requirements. (Built-in support for isolation of senders and receivers is only provided in COM+ infrastructure).
Yet another task that needs to be solved when creating modular object-oriented applications, is cross-platform portability, so that the application can be easily transferred to a different operating system. It is highly desirable for an object-oriented infrastructure to provide an isolation of application objects from low-level application programming interfaces (APIs) of the operating system. Ideally, an object-oriented infrastructure can fully isolate components implementing the application logic from a platform-dependent program interface, so that platform-independent components can be created.
U.S. Pat. No. 6,606,742 describes an object-oriented interface that provides applications with access to functionality of the operating system. The system described herein includes a loader that dynamically loads needed fragments of executable code providing required functionality of the operating system.
U.S. Pat. No. 5,583,983 describes a system for developing object-oriented applications. The system implements a program code structure in the form of archive that contains definitions of programmable objects. The structures saved in the archive can be de-archived for implementation on different operating platforms. The system creates copies of platform-independent object implementations.
U.S. Pat. No. 7,225,426 describes a system that implements tree object structure. Each object has a number of slots containing values of properties of the object. Property slots can be defined when the object is created or they can be dynamically added in run time.
The references discussed above address only a few of particular aspects of developing applications based on object-oriented infrastructure. However, efficient development of programmable applications requires a comprehensive approach to solving the typical tasks discussed earlier. Therefore, there is a need in the art for a high level object-oriented component infrastructure directed to solving typical common tasks with regards to development of software applications and systems.